home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / slzwd.c < prev    next >
C/C++ Source or Header  |  1996-02-27  |  10KB  |  369 lines
  1. /* Copyright (C) 1993, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* slzwd.c */
  20. /* LZW decoding filter */
  21. #include "stdio_.h"    /* includes std.h */
  22. #include "gdebug.h"
  23. #include "strimpl.h"
  24. #include "slzwx.h"
  25.  
  26. /* ------ LZWDecode ------ */
  27.  
  28. /********************************************************/
  29. /* LZW routines are based on:                */
  30. /* Dr. Dobbs Journal --- Oct. 1989.             */
  31. /* Article on LZW Data Compression by Mark R. Nelson     */
  32. /********************************************************/
  33.  
  34. /* Define the special codes in terms of code_escape, which is */
  35. /* 1 << InitialCodeLength. */
  36. #define code_reset (code_escape + 0)
  37. #define code_eod (code_escape + 1)
  38. #define code_0 (code_escape + 2)        /* first assignable code */
  39.  
  40. struct lzw_decode_s {
  41.     byte datum;
  42.     byte len;            /* length of code */
  43.     ushort prefix;            /* code to be prefixed */
  44. };
  45. gs_private_st_simple(st_lzw_decode, lzw_decode, "lzw_decode");
  46. /* We can use a simple type as the element type, */
  47. /* because there are no pointers to enumerate or relocate. */
  48. #define st_lzw_decode_element st_lzw_decode
  49. #define lzw_decode_max 4096        /* must be 4096 */
  50.  
  51. #define ss ((stream_LZW_state *)st)
  52.  
  53. /* Initialize LZWDecode filter */
  54. /* We separate out the reset function for some non-stream clients. */
  55. int
  56. s_LZWD_reset(stream_state *st)
  57. {    register lzw_decode *dc = ss->table.decode;
  58.     register int i;
  59.     uint code_escape = 1 << ss->InitialCodeLength;
  60.  
  61.     ss->bits_left = 0;
  62.     ss->bytes_left = 0;
  63.     ss->next_code = code_0;
  64.     ss->code_size = ss->InitialCodeLength + 1;
  65.     ss->prev_code = -1;
  66.     ss->copy_code = -1;
  67.     dc[code_reset].len = 255;
  68.     dc[code_eod].len = 255;
  69.     for ( i = 0; i < code_escape; i++, dc++ )
  70.       dc->datum = i, dc->len = 1, dc->prefix = code_eod;
  71.     return 0;
  72. }
  73. private int
  74. s_LZWD_init(stream_state *st)
  75. {    lzw_decode *dc =
  76.       gs_alloc_struct_array(st->memory, lzw_decode_max + 1,
  77.                 lzw_decode, &st_lzw_decode_element,
  78.                 "LZWDecode(init)");
  79.  
  80.     if ( dc == 0 )
  81.       return ERRC;        /****** WRONG ******/
  82.     ss->table.decode = dc;
  83.     return s_LZWD_reset(st);
  84. }
  85.  
  86. /* Process a buffer */
  87. private int
  88. s_LZWD_process(stream_state *st, stream_cursor_read *pr,
  89.   stream_cursor_write *pw, bool last)
  90. {    register const byte *p = pr->ptr;
  91.     register byte *q = pw->ptr;
  92. #ifdef DEBUG
  93.     byte *q0 = q;
  94. #endif
  95.     const byte *rlimit = pr->limit;            /* constant pointer */
  96.     byte *wlimit = pw->limit;            /* constant pointer */
  97.     int status = 0;
  98.     int code = ss->copy_code;
  99.     int prev_code = ss->prev_code;
  100.     uint prev_len = ss->prev_len;
  101.     byte bits = ss->bits;
  102.     int bits_left = ss->bits_left;
  103.     int bytes_left = ss->bytes_left;
  104.     int code_size = ss->code_size;
  105.     int code_mask;
  106.     int switch_code;
  107.     int next_code = ss->next_code;
  108.     lzw_decode *table = ss->table.decode;        /* constant pointer */
  109.     lzw_decode *dc_next = table + next_code;    /* invariant */
  110.     lzw_decode *dc;
  111.     int code_escape = 1 << ss->InitialCodeLength;
  112.     int eod = code_eod;
  113.     bool low_order = ss->FirstBitLowOrder;
  114.     uint len;
  115.     int c;
  116.     byte b;
  117.     byte *q1;
  118.     if_debug2('w', "[w]process decode: code_size=%d next_code=%d\n",
  119.           code_size, next_code);
  120. #define set_code_size()\
  121.   code_mask = (1 << code_size) - 1,\
  122.   switch_code = code_mask + 1 - ss->EarlyChange
  123.     set_code_size();
  124.     if ( !ss->BlockData )
  125.       bytes_left = rlimit - p + 2;     /* never stop for bytes_left */
  126.     /* If we are in the middle of copying a string, */
  127.     /* do some more now. */
  128.     if ( code >= 0 )
  129.     {    int rlen = ss->copy_left;
  130.         int wlen = wlimit - q;
  131.         int n = len = min(rlen, wlen);
  132.         c = code;
  133.         ss->copy_left = rlen -= len;
  134.         if_debug3('W', "[W]copying 0x%x, %d byte(s) out of %d left\n",
  135.               code, len, rlen + len);
  136.         while ( rlen )
  137.             c = table[c].prefix,
  138.             rlen--;
  139.         q1 = q += len;
  140.         n = len;
  141.         while ( --n >= 0 )
  142.         {    *q1-- = (dc = &table[c])->datum;
  143.             c = dc->prefix;
  144.         }
  145.         if ( ss->copy_left )            /* more to do */
  146.         {    pw->ptr = q;
  147.             return 1;
  148.         }
  149.         ss->copy_code = -1;
  150.         len = ss->copy_len;
  151.         /* Retrieve the first byte of the code just copied. */
  152.         if ( c == eod )
  153.         {    /* We just copied the entire code, */
  154.             /* so the byte we want is immediately available. */
  155.             b = q1[1];
  156.         }
  157.         else
  158.         {    /* We have to scan to the beginning of the code. */
  159.             for ( ; c != eod; c = table[c].prefix )
  160.                 b = (byte)c;
  161.         }
  162.         goto add;
  163.     }
  164. top:    if ( code_size > bits_left )
  165.       {    if ( bytes_left == 0 )
  166.           {    if ( p == rlimit )
  167.               goto out;
  168.             bytes_left = *++p;
  169.             if_debug1('W', "[W]block count %d\n", bytes_left);
  170.             if ( bytes_left == 0 )
  171.               {    status = EOFC;
  172.                 goto out;
  173.               }
  174.             goto top;
  175.           }
  176.         if ( low_order )
  177.           code = bits >> (8 - bits_left);
  178.         else
  179.           code = (uint)bits << (code_size - bits_left);
  180.         if ( bits_left + 8 < code_size )
  181.           {    /* Need 2 more data bytes */
  182.             if ( bytes_left == 1 )
  183.               {    if ( rlimit - p < 3 )
  184.                   goto out;
  185.                 bytes_left = p[2];
  186.                 if_debug1('W', "[W]block count %d\n",
  187.                       bytes_left);
  188.                 if ( bytes_left == 0 )
  189.                   {    status = EOFC;
  190.                     goto out;
  191.                   }
  192.                 bytes_left++;
  193.                 bits = p[1];
  194.                 p++;
  195.               }
  196.             else
  197.               {    if ( rlimit - p < 2 )
  198.                   goto out;
  199.                 bits = p[1];
  200.               }
  201.             if ( low_order )
  202.               code += (uint)bits << bits_left;
  203.             else
  204.               code += (uint)bits << (code_size - 8 - bits_left);
  205.             bits_left += 8;
  206.             bits = p[2];
  207.             p += 2;
  208.             bytes_left -= 2;
  209.           }
  210.         else
  211.           {    if ( p == rlimit )
  212.               goto out;
  213.             bits = *++p;
  214.             bytes_left--;
  215.           }
  216.         if ( low_order )
  217.           code += (uint)bits << bits_left,
  218.           bits_left += 8 - code_size;
  219.         else
  220.           bits_left += 8 - code_size,
  221.           code += bits >> bits_left;
  222.       }
  223.     else
  224.       {    if ( low_order )
  225.           code = bits >> (8 - bits_left),
  226.           bits_left -= code_size;
  227.         else
  228.           bits_left -= code_size,
  229.           code = bits >> bits_left;
  230.       }
  231.     code &= code_mask;
  232.     if_debug2('W', "[W]reading 0x%x,%d\n", code, code_size);
  233.     /*
  234.      * There is an anomalous case where a code S is followed
  235.      * immediately by another occurrence of the S string.
  236.      * In this case, the next available code will be defined as
  237.      * S followed by the first character of S, and will be
  238.      * emitted immediately after the code S.  We have to
  239.      * recognize this case specially, by noting that the code is
  240.      * equal to next_code.
  241.      */
  242.     if ( code >= next_code )
  243.     {    if ( code > next_code )
  244.           {
  245. #ifdef DEBUG
  246.             lprintf2("[W]code = %d > next_code = %d\n",
  247.                  code, next_code);
  248. #endif
  249.             status = ERRC;
  250.             goto out;
  251.           }
  252.         /* Fabricate the entry for the code.  It will be */
  253.         /* overwritten immediately, of course. */
  254.         for ( c = prev_code; c != eod; c = table[c].prefix )
  255.             dc_next->datum = c;
  256.         len = prev_len + 1;
  257.         dc_next->len = min(len, 255);
  258.         dc_next->prefix = prev_code;
  259.         if_debug3('w', "[w]decoding anomalous 0x%x=0x%x+%c\n",
  260.               next_code, prev_code, dc_next->datum);
  261.     }
  262.     /* See if there is enough room for the code. */
  263.     len = table[code].len;
  264.     if ( len == 255 )
  265.     {    /* Check for special code (reset or end). */
  266.         /* We set their lengths to 255 to avoid doing */
  267.         /* an extra check in the normal case. */
  268.         if ( code == code_reset )
  269.         {    if_debug1('w', "[w]reset: next_code was %d\n",
  270.                   next_code);
  271.             next_code = code_0;
  272.             dc_next = table + code_0;
  273.             code_size = ss->InitialCodeLength + 1;
  274.             set_code_size();
  275.             prev_code = -1;
  276.             goto top;
  277.         }
  278.         else if ( code == eod )
  279.         {    status = EOFC;
  280.             goto out;
  281.         }
  282.         /* The code length won't fit in a byte, */
  283.         /* compute it the hard way. */
  284.         for ( c = code, len = 0; c != eod; len++ )
  285.             c = table[c].prefix;
  286.         if_debug2('w', "[w]long code %d, length=%d\n", code, len);
  287.     }
  288.     if ( wlimit - q < len )
  289.     {    ss->copy_code = code;
  290.         ss->copy_left = ss->copy_len = len;
  291.         status = 1;
  292.         goto out;
  293.     }
  294.     /* Copy the string to the buffer (back to front). */
  295.     /* Optimize for short codes, which are the most frequent. */
  296.     dc = &table[code];
  297.     switch ( len )
  298.     {
  299.     default:
  300.     {    byte *q1 = q += len;
  301.         c = code;
  302.         do
  303.         {    *q1-- = (dc = &table[c])->datum;
  304.         }
  305.         while ( (c = dc->prefix) != eod );
  306.         b = q1[1];
  307.     }    break;
  308.     case 3:
  309.         q[3] = dc->datum;
  310.         dc = &table[dc->prefix];
  311.     case 2:
  312.         q[2] = dc->datum;
  313.         dc = &table[dc->prefix];
  314.     case 1:
  315.         q[1] = b = dc->datum;
  316.         q += len;
  317.     }
  318. add:    /* Add a new entry to the table */
  319.     if ( prev_code >= 0 )
  320.     {    /* Unfortunately, we have to check for next_code == */
  321.         /* lzw_decode_max every time: just checking at power */
  322.         /* of 2 boundaries stops us one code too soon. */
  323.         if ( next_code == lzw_decode_max )
  324.         {    status = ERRC;
  325.             goto out;
  326.         }
  327.         dc_next->datum = b;        /* added char of string */
  328.         dc_next->len = min(prev_len, 254) + 1;
  329.         dc_next->prefix = prev_code;
  330.         dc_next++;
  331.         if_debug4('W', "[W]adding 0x%x=0x%x+%c(%d)\n",
  332.               next_code, prev_code, b, min(len, 255));
  333.         if ( ++next_code == switch_code )
  334.         {    /* Crossed a power of 2. */
  335.             /* We have to make a strange special check for */
  336.             /* reaching the end of the code space. */
  337.             if ( next_code < lzw_decode_max - 1 )
  338.             {    code_size++;
  339.                 set_code_size();
  340.                 if_debug2('w', "[w]crossed power of 2: new code_size=%d, next_code=%d\n",
  341.                       code_size, next_code);
  342.             }
  343.         }
  344.     }
  345.     prev_code = code;
  346.     prev_len = len;
  347.     goto top;
  348. out:    pr->ptr = p;
  349.     pw->ptr = q;
  350.     ss->code_size = code_size;
  351.     ss->prev_code = prev_code;
  352.     ss->prev_len = prev_len;
  353.     ss->bits = bits;
  354.     ss->bits_left = bits_left;
  355.     ss->bytes_left = bytes_left;
  356.     ss->next_code = next_code;
  357.     if_debug3('w', "[w]decoded %d bytes, prev_code=%d, next_code=%d\n",
  358.           (int)(q - q0), prev_code, next_code);
  359.     return status;
  360. }
  361.  
  362. #undef ss
  363.  
  364. /* Stream template */
  365. const stream_template s_LZWD_template =
  366. {    &st_LZW_state, s_LZWD_init, s_LZWD_process, 3, 1, s_LZW_release,
  367.     s_LZW_set_defaults, s_LZWD_reset
  368. };
  369.